/*#include "../easyunit/test.h"
#include "FactoryTest.h"

#include "../source/strategy/OptimalSmallCover.h"
#include <iostream> 	
using namespace easyunit;

DECLARE(OptimalSmallCover)
	FactoryTest* f;
	OptimalSmallCover* optimalSmallCover;
	Graph *g1, *g2, *g3, *g4, *g5, *g6, *g7, *g8, *g9, *g10, *g11, *g12, *g13;

END_DECLARE

SETUP(OptimalSmallCover)
{
	f = FactoryTest::getInstance();

	g1 = f->createGraph1();
	g1->setStrategy(new OptimalSmallCover(0));

	g2 = f->createGraph2();
	g2->setStrategy(new OptimalSmallCover(0));

	g3 = f->createGraph3();
	g3->setStrategy(new OptimalSmallCover(6));

	g4 = f->createGraph4();
	g4->setStrategy(new OptimalSmallCover(9));;

	g5 = f->createGraph5();
	g5->setStrategy(new OptimalSmallCover(499));

	g6 = f->createGraph6();
	g6->setStrategy(new OptimalSmallCover(2));

	g7 = f->createGraph7();
	g7->setStrategy(new OptimalSmallCover(2));

	g8 = f->createGraph8();
	g8->setStrategy(new OptimalSmallCover(6));

	g9 = f->createGraph9();
	g9->setStrategy(new OptimalSmallCover(1));

	g10 = f->createGraph10();
	g10->setStrategy(new OptimalSmallCover(5));

	g11 = f->createGraph11();
	g11->setStrategy(new OptimalSmallCover(5));
	
	g12 = f->createGraph12();
	g12->setStrategy(new OptimalSmallCover(5));

	g13 = f->createGraph13();
	g13->setStrategy(new OptimalSmallCover(1));
}

TEARDOWN(OptimalSmallCover)
{
	delete g1;
	delete g2;
	delete g3;
	delete g4;
	delete g5;
	delete g6;
	delete g7;
	delete g8;
	delete g9;
	delete g10;
	delete g11;
	delete g12;
	delete g13;
	delete optimalSmallCover;
	delete f;
}

TESTF(OptimalSmallCover, vertexCover)
{
	list<int> cover;
 	cover = g1->launchVertexCover();
	ASSERT_TRUE(cover.empty());

 	cover = g2->launchVertexCover();
	ASSERT_TRUE(cover.empty());

 	cover = g3->launchVertexCover();
	int expectedg3[] = {1, 2, 3, 6, 8, 10};
	ASSERT_TRUE(cover.size() == ((sizeof expectedg3)/(sizeof expectedg3[0])));
	ASSERT_TRUE(equal(cover.begin(), cover.end(), expectedg3));*/
	  /*
	So long...
	cover = g4->launchVertexCover();
	ASSERT_TRUE((int)cover.size() == g4->numberOfNode() -1);

	cover = g5->launchVertexCover();
	ASSERT_TRUE((int)cover.size() == g5->numberOfNode() -1);

/*	cover = g6->launchVertexCover();
	int expectedg6[] = {2, 4};
	ASSERT_TRUE(cover.size() == ((sizeof expectedg6)/(sizeof expectedg6[0])));
	ASSERT_TRUE(equal(cover.begin(), cover.end(), expectedg6));

	cover = g7->launchVertexCover();
	int expectedg7[] = {5, 6};
	ASSERT_TRUE(cover.size() == ((sizeof expectedg7)/(sizeof expectedg7[0])));
	ASSERT_TRUE(equal(cover.begin(), cover.end(), expectedg7));

	cover = g8->launchVertexCover();
	int expectedg8[] = {1, 2, 4, 5, 7, 8};
	ASSERT_TRUE(cover.size() == ((sizeof expectedg8)/(sizeof expectedg8[0])));
	ASSERT_TRUE(equal(cover.begin(), cover.end(), expectedg8));

	cover = g9->launchVertexCover();
	int expectedg9[] = {1};
	ASSERT_TRUE(cover.size() == ((sizeof expectedg9)/(sizeof expectedg9[0])));
	ASSERT_TRUE(equal(cover.begin(), cover.end(), expectedg9));

	cover = g10->launchVertexCover();
	int expectedg10[] = {1, 3, 5, 7, 9};
	ASSERT_TRUE(cover.size() == ((sizeof expectedg10)/(sizeof expectedg10[0])));
	ASSERT_TRUE(equal(cover.begin(), cover.end(), expectedg10));
	
	cover = g11->launchVertexCover();
	ASSERT_TRUE(cover.size() == ((sizeof expectedg10)/(sizeof expectedg10[0])));
	ASSERT_TRUE(equal(cover.begin(), cover.end(), expectedg10));
	
	cover = g12->launchVertexCover();
	int expectedg12[] = {1, 4, 5, 6, 9};
	ASSERT_TRUE(cover.size() == ((sizeof expectedg12)/(sizeof expectedg12[0])));
	ASSERT_TRUE(equal(cover.begin(), cover.end(), expectedg12));

	cover = g13->launchVertexCover();
	int expectedg13[] = {1};
	ASSERT_TRUE(cover.size() == ((sizeof expectedg13)/(sizeof expectedg13[0])));
	ASSERT_TRUE(equal(cover.begin(), cover.end(), expectedg13));
}
*/
